package com.orangelife.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.orangelife.setting.constant.TypeConst;

public class DateUtil {
	public static final String YYYY_MM = "yyyy-MM";
	public static final String YYYY_MM_DD = "yyyy-MM-dd";
	public static final String YYYY_MM_DDT = "yyyy-M-d";
	public static final String HH_MM_SS = "HH:mm:ss";
	public static final String YYYY_MM_DD_HH_MM_SS = "yyyy-MM-dd HH:mm:ss";

	public static void main(String[] args) {
		
		
	System.out.println(getNextQuarter("2016-07"));	;
		// System.out.println(isNotTime("0900-1900"));
		System.out.println(isNotTime("1", "3", 1, 8, 1441691916000l,
				1441791916000l));
//System.out.println(getTimeByCurTime(new Date(),Calendar.DATE,1,1));
//System.out.println(DateToString(new Date(getTimeByCurMon(new Date(),1,0)),YYYY_MM_DD_HH_MM_SS));

		// Calendar aCalendar = Calendar.getInstance(Locale.CHINA);
		// int day = aCalendar.getActualMaximum(Calendar.DATE);
		// System.out.println(day);
	}

	/**
	 * 判断是否在某个时间段内
	 * 
	 * @author zhr
	 * @date 2015年8月6日
	 * @param playRegions
	 *            例：0900-1700
	 * @return
	 */
	public static boolean isNotTime(String playRegions) {
		boolean b = false;
		if (StringUtils.isNotBlank(playRegions)
				&& playRegions.indexOf("-") != -1) {
			int beginRegionTime = 0;
			int endRegionTime = 0;
			Date d = new Date();
			SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HHmm",
					java.util.Locale.US);

			String str = simpleDateFormat.format(d);
			int currentTime = Integer.parseInt(str);
			String beginRegionTimeStr = playRegions.split("-")[0];
			String endRegionTimeStr = playRegions.split("-")[1];
			if (StringUtils.isNotBlank(beginRegionTimeStr)) {
				beginRegionTime = Integer.parseInt(beginRegionTimeStr);
			}
			if (StringUtils.isNotBlank(endRegionTimeStr)) {
				endRegionTime = Integer.parseInt(endRegionTimeStr);
			}
			// 如果当前时间在广告播放时间段里面
			if (currentTime >= beginRegionTime && currentTime <= endRegionTime) {
				System.out.println("时间段内");
				b = true;
			} else {
				System.out.println("时间段外");
				b = false;
			}
		}
		return b;
	}

	/**
	 * 判断是否大于开始时间
	 * 
	 * @author zhr
	 * @date 2015年8月6日
	 * @param playRegions
	 *            例：0900
	 * @return
	 */
	public static boolean isStartTime(String startTime) {
		boolean b = false;
		int startTimes = 0;
		Date d = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HHmm",
				java.util.Locale.US);

		String str = simpleDateFormat.format(d);
		int currentTime = Integer.parseInt(str);
		if (StringUtils.isNotBlank(startTime)) {
			startTimes = Integer.parseInt(startTime);
		}
		// 如果当前时间在广告播放时间段里面
		if (currentTime >= startTimes) {
			System.out.println("当前时间大于开始时间");
			b = true;
		} else {
			b = false;
		}
		return b;
	}

	/**
	 * 判断是否小于结束时间
	 * 
	 * @author zhr
	 * @date 2015年8月6日
	 * @param playRegions
	 *            例：0900
	 * @return
	 */
	public static boolean isEndTime(String endTime) {
		boolean b = false;
		int endTimes = 0;
		Date d = new Date();
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat("HHmm",
				java.util.Locale.US);

		String str = simpleDateFormat.format(d);
		int currentTime = Integer.parseInt(str);
		if (StringUtils.isNotBlank(endTime)) {
			endTimes = Integer.parseInt(endTime);
		}
		// 如果当前时间在广告播放时间段里面
		if (currentTime <= endTimes) {
			System.out.println("当前时间小于结束时间");
			b = true;
		} else {
			b = false;
		}
		return b;
	}

	/**
	 * 判断当前时间是否在上下架时间之外
	 * 
	 * @author zhr
	 * @date 2015年8月19日
	 * @param shelves
	 *            0下架1上架
	 * @param timeType
	 *            1.每月；2.每周；3.自定义
	 * @param startDay
	 *            开始 time_type为1（存1-31），为2（存1-7代表周日到周六）
	 * @param endDay
	 *            结束 time_type为1（存1-31），为2（存1-7代表周日到周六）
	 * @param startTime
	 *            开始时间(time_type为1,2存时分1000，为3存时间戳)
	 * @param endTime
	 *            结束时间(time_type为1,2存时分1000，为3存时间戳)
	 * @return false 下架 true上架
	 */
	public static boolean isNotTime(String shelves, String timeType,
			Integer startDay, Integer endDay, Long startTime, Long endTime) {
		boolean b = false;
		if (TypeConst.SHELVES_PUT_ON.equals(shelves)) {

			if (startDay == null) {
				startDay = 0;
			}
			if (endDay == null) {
				endDay = 0;
			}
			if (startTime == null) {
				startTime = 0l;
			}
			if (endTime == null) {
				endTime = 0l;
			}

			if (StringUtils.isBlank(timeType)
					|| TypeConst.DATEUTIL_TIME_TYPE_NOT_LIMITED
							.equals(timeType)) {
				b = true;
			} else {
				Calendar cal = Calendar.getInstance();
				cal.setTime(new Date());
				if (TypeConst.DATEUTIL_TIME_TYPE_MONTH.equals(timeType)) {
					int day = cal.get(Calendar.DAY_OF_MONTH);

					if (startDay <= endDay) {
						if (day >= startDay && day <= endDay) {
							b = true;
						}
					} else {
						if (day >= startDay || day <= endDay) {
							b = true;
						}
					}

					if (day == startDay && day == endDay) {
						String playRegions = startTime + "-" + endTime;
						b = isNotTime(playRegions);
					}

					/**
					 * 是否大于上架时间
					 */
					if (day == startDay) {
						b = isStartTime(startTime + "");
					}

					/**
					 * 是否小于下架时间
					 */
					if (day == endDay) {
						b = isEndTime(endTime + "");
					}

				} else if (TypeConst.DATEUTIL_TIME_TYPE_WEEK.equals(timeType)) {
					int week = cal.get(Calendar.DAY_OF_WEEK);

					if (startDay <= endDay) {
						if (week >= startDay && week <= endDay) {
							b = true;
						}
					} else {
						if (week >= startDay || week <= endDay) {
							b = true;
						}
					}

					if (week == startDay && week == endDay) {
						String playRegions = startTime + "-" + endTime;
						b = isNotTime(playRegions);
					}

					/**
					 * 是否大于上架时间
					 */
					if (week == startDay) {
						b = isStartTime(startTime + "");
					}

					/**
					 * 是否小于下架时间
					 */
					if (week == endDay) {
						b = isEndTime(endTime + "");
					}

				} else if (TypeConst.DATEUTIL_TIME_TYPE_USER_DEFINED
						.equals(timeType)) {
					// long date1 = new Date().getTime();
					long date = System.currentTimeMillis();
					if (date >= startTime && date <= endTime) {
						b = true;
					}

				} else if (TypeConst.DATEUTIL_TIME_TYPE_NOT_LIMITED
						.equals(timeType)) {
					b = true;
				}
			}
		} else {
			b = false;
		}
		return b;
	}

	/**
	 * 获取年月 格式如 2014-11
	 * 
	 * @param withSeparator
	 *            是否带横线
	 * @return
	 */
	public static String getCurrentYearMonth(boolean withSeparator) {
		return new SimpleDateFormat(withSeparator ? "yyyy-MM"
				: deleteSaparator("yyyy-MM")).format(new Date());
	}

	/**
	 * 获取年月日 格式如 2014-11-11
	 * 
	 * @param withSeparator
	 *            是否带横线
	 * @return
	 */
	public static String getCurrentDate(boolean withSeparator) {
		return new SimpleDateFormat(withSeparator ? "yyyy-MM-dd"
				: deleteSaparator("yyyy-MM-dd")).format(new Date());
	}

	/**
	 * 获取年月日 格式如 2014-11-1 （不带0）
	 * 
	 * @param withSeparator
	 *            是否带横线
	 * @return
	 */

	public static String getCurrentDateT(boolean withSeparator) {
		return new SimpleDateFormat(withSeparator ? "yyyy-M-d"
				: deleteSaparator("yyyy-M-d")).format(new Date());
	}

	/**
	 * 获取时分秒 格式如 2014-11-11 11：03：11
	 * 
	 * @param withSeparator
	 *            是否带冒号 横向
	 * @return
	 */
	public static String getCurrentTime(boolean withSeparator) {
		return new SimpleDateFormat(withSeparator ? "HH:mm:ss"
				: deleteSaparator("HH:mm:ss")).format(new Date());
	}

	/**
	 * 获取时分秒 格式如 11：03：11
	 * 
	 * @param withSeparator
	 *            是否带冒号
	 * @return
	 */
	public static String getCurrentDateTime(boolean withSeparator) {
		return new SimpleDateFormat(withSeparator ? "yyyy-MM-dd HH:mm:ss"
				: deleteSaparator("yyyy-MM-dd HH:mm:ss")).format(new Date());
	}

	/**
	 * 时间戳转为 固定格式 yyyy-MM-dd HH:mm:ss
	 * 
	 * @param dateTime
	 * @return
	 * @throws ParseException
	 */
	public static Date getDateTime(String dateTime) throws ParseException {
		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(dateTime);
	}

	/**
	 * 时间戳转为 固定格式 yyyy-MM-dd HH:mm:ss
	 * 
	 * @param dateTime
	 * @return
	 * @throws ParseException
	 */
	public static Date getDate(String date) throws ParseException {
		return new SimpleDateFormat("yyyy-MM-dd").parse(date);
	}

	public static String deleteSaparator(String str) {
		return new StringBuffer(str).toString().replaceAll("-", "")
				.replaceAll(":", "");

	}

	/**
	 * 获取SimpleDateFormat
	 * 
	 * @param parttern
	 *            日期格式
	 * @return SimpleDateFormat对象
	 * @throws RuntimeException
	 *             异常：非法日期格式
	 */
	private static SimpleDateFormat getDateFormat(String parttern)
			throws RuntimeException {
		return new SimpleDateFormat(parttern);
	}

	/**
	 * 获取日期中的某数值。如获取月份
	 * 
	 * @param date
	 *            日期
	 * @param dateType
	 *            日期格式
	 * @return 数值
	 */
	private static int getInteger(Date date, int dateType) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		return calendar.get(dateType);
	}

	/**
	 * 增加日期中某类型的某数值。如增加日期
	 * 
	 * @param date
	 *            日期字符串
	 * @param dateType
	 *            类型
	 * @param amount
	 *            数值
	 * @return 计算后日期字符串
	 */
	private static String addInteger(String date, int dateType, int amount) {
		String dateString = null;
		DateStyle dateStyle = getDateStyle(date);
		if (dateStyle != null) {
			Date myDate = StringToDate(date, dateStyle);
			myDate = addInteger(myDate, dateType, amount);
			dateString = DateToString(myDate, dateStyle);
		}
		return dateString;
	}

	/**
	 * 增加日期中某类型的某数值。如增加日期
	 * 
	 * @param date
	 *            日期
	 * @param dateType
	 *            类型
	 * @param amount
	 *            数值
	 * @return 计算后日期
	 */
	private static Date addInteger(Date date, int dateType, int amount) {
		Date myDate = null;
		if (date != null) {
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			calendar.add(dateType, amount);
			myDate = calendar.getTime();
		}
		return myDate;
	}

	/**
	 * 获取精确的日期
	 * 
	 * @param timestamps
	 *            时间long集合
	 * @return 日期
	 */
	private static Date getAccurateDate(List<Long> timestamps) {
		Date date = null;
		long timestamp = 0;
		Map<Long, long[]> map = new HashMap<Long, long[]>();
		List<Long> absoluteValues = new ArrayList<Long>();

		if (timestamps != null && timestamps.size() > 0) {
			if (timestamps.size() > 1) {
				for (int i = 0; i < timestamps.size(); i++) {
					for (int j = i + 1; j < timestamps.size(); j++) {
						long absoluteValue = Math.abs(timestamps.get(i)
								- timestamps.get(j));
						absoluteValues.add(absoluteValue);
						long[] timestampTmp = { timestamps.get(i),
								timestamps.get(j) };
						map.put(absoluteValue, timestampTmp);
					}
				}

				// 有可能有相等的情况。如2012-11和2012-11-01。时间戳是相等的
				long minAbsoluteValue = -1;
				if (!absoluteValues.isEmpty()) {
					// 如果timestamps的size为2，这是差值只有一个，因此要给默认值
					minAbsoluteValue = absoluteValues.get(0);
				}
				for (int i = 0; i < absoluteValues.size(); i++) {
					for (int j = i + 1; j < absoluteValues.size(); j++) {
						if (absoluteValues.get(i) > absoluteValues.get(j)) {
							minAbsoluteValue = absoluteValues.get(j);
						} else {
							minAbsoluteValue = absoluteValues.get(i);
						}
					}
				}

				if (minAbsoluteValue != -1) {
					long[] timestampsLastTmp = map.get(minAbsoluteValue);
					if (absoluteValues.size() > 1) {
						timestamp = Math.max(timestampsLastTmp[0],
								timestampsLastTmp[1]);
					} else if (absoluteValues.size() == 1) {
						// 当timestamps的size为2，需要与当前时间作为参照
						long dateOne = timestampsLastTmp[0];
						long dateTwo = timestampsLastTmp[1];
						if ((Math.abs(dateOne - dateTwo)) < 100000000000L) {
							timestamp = Math.max(timestampsLastTmp[0],
									timestampsLastTmp[1]);
						} else {
							long now = new Date().getTime();
							if (Math.abs(dateOne - now) <= Math.abs(dateTwo
									- now)) {
								timestamp = dateOne;
							} else {
								timestamp = dateTwo;
							}
						}
					}
				}
			} else {
				timestamp = timestamps.get(0);
			}
		}

		if (timestamp != 0) {
			date = new Date(timestamp);
		}
		return date;
	}

	/**
	 * 判断字符串是否为日期字符串
	 * 
	 * @param date
	 *            日期字符串
	 * @return true or false
	 */
	public static boolean isDate(String date) {
		boolean isDate = false;
		if (date != null) {
			if (StringToDate(date) != null) {
				isDate = true;
			}
		}
		return isDate;
	}

	/**
	 * 获取日期字符串的日期风格。失敗返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 日期风格
	 */
	public static DateStyle getDateStyle(String date) {
		DateStyle dateStyle = null;
		Map<Long, DateStyle> map = new HashMap<Long, DateStyle>();
		List<Long> timestamps = new ArrayList<Long>();
		for (DateStyle style : DateStyle.values()) {
			Date dateTmp = StringToDate(date, style.getValue());
			if (dateTmp != null) {
				timestamps.add(dateTmp.getTime());
				map.put(dateTmp.getTime(), style);
			}
		}
		dateStyle = map.get(getAccurateDate(timestamps).getTime());
		return dateStyle;
	}

	/**
	 * 将日期字符串转化为日期。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 日期
	 */
	public static Date StringToDate(String date) {
		DateStyle dateStyle = null;
		return StringToDate(date, dateStyle);
	}

	/**
	 * 将日期字符串转化为日期。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param parttern
	 *            日期格式
	 * @return 日期
	 */
	public static Date StringToDate(String date, String parttern) {
		Date myDate = null;
		if (date != null) {
			try {
				myDate = getDateFormat(parttern).parse(date);
			} catch (Exception e) {
			}
		}
		return myDate;
	}

	/**
	 * 将日期字符串转化为日期。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param dateStyle
	 *            日期风格
	 * @return 日期
	 */
	public static Date StringToDate(String date, DateStyle dateStyle) {
		Date myDate = null;
		if (dateStyle == null) {
			List<Long> timestamps = new ArrayList<Long>();
			for (DateStyle style : DateStyle.values()) {
				Date dateTmp = StringToDate(date, style.getValue());
				if (dateTmp != null) {
					timestamps.add(dateTmp.getTime());
				}
			}
			myDate = getAccurateDate(timestamps);
		} else {
			myDate = StringToDate(date, dateStyle.getValue());
		}
		return myDate;
	}

	/**
	 * 将日期转化为日期字符串。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param parttern
	 *            日期格式
	 * @return 日期字符串
	 */
	public static String DateToString(Date date, String parttern) {
		String dateString = null;
		if (date != null) {
			try {
				dateString = getDateFormat(parttern).format(date);
			} catch (Exception e) {
			}
		}
		return dateString;
	}

	/**
	 * 将日期转化为日期字符串。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param dateStyle
	 *            日期风格
	 * @return 日期字符串
	 */
	public static String DateToString(Date date, DateStyle dateStyle) {
		String dateString = null;
		if (dateStyle != null) {
			dateString = DateToString(date, dateStyle.getValue());
		}
		return dateString;
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * 
	 * @param date
	 *            旧日期字符串
	 * @param parttern
	 *            新日期格式
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, String parttern) {
		return StringToString(date, null, parttern);
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * 
	 * @param date
	 *            旧日期字符串
	 * @param dateStyle
	 *            新日期风格
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, DateStyle dateStyle) {
		return StringToString(date, null, dateStyle);
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * 
	 * @param date
	 *            旧日期字符串
	 * @param olddParttern
	 *            旧日期格式
	 * @param newParttern
	 *            新日期格式
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, String olddParttern,
			String newParttern) {
		String dateString = null;
		if (olddParttern == null) {
			DateStyle style = getDateStyle(date);
			if (style != null) {
				Date myDate = StringToDate(date, style.getValue());
				dateString = DateToString(myDate, newParttern);
			}
		} else {
			Date myDate = StringToDate(date, olddParttern);
			dateString = DateToString(myDate, newParttern);
		}
		return dateString;
	}

	/**
	 * 将日期字符串转化为另一日期字符串。失败返回null。
	 * 
	 * @param date
	 *            旧日期字符串
	 * @param olddDteStyle
	 *            旧日期风格
	 * @param newDateStyle
	 *            新日期风格
	 * @return 新日期字符串
	 */
	public static String StringToString(String date, DateStyle olddDteStyle,
			DateStyle newDateStyle) {
		String dateString = null;
		if (olddDteStyle == null) {
			DateStyle style = getDateStyle(date);
			dateString = StringToString(date, style.getValue(),
					newDateStyle.getValue());
		} else {
			dateString = StringToString(date, olddDteStyle.getValue(),
					newDateStyle.getValue());
		}
		return dateString;
	}

	/**
	 * 增加日期的年份。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param yearAmount
	 *            增加数量。可为负数
	 * @return 增加年份后的日期字符串
	 */
	public static String addYear(String date, int yearAmount) {
		return addInteger(date, Calendar.YEAR, yearAmount);
	}

	/**
	 * 增加日期的年份。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param yearAmount
	 *            增加数量。可为负数
	 * @return 增加年份后的日期
	 */
	public static Date addYear(Date date, int yearAmount) {
		return addInteger(date, Calendar.YEAR, yearAmount);
	}

	/**
	 * 增加日期的月份。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param yearAmount
	 *            增加数量。可为负数
	 * @return 增加月份后的日期字符串
	 */
	public static String addMonth(String date, int yearAmount) {
		return addInteger(date, Calendar.MONTH, yearAmount);
	}

	/**
	 * 增加日期的月份。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param yearAmount
	 *            增加数量。可为负数
	 * @return 增加月份后的日期
	 */
	public static Date addMonth(Date date, int yearAmount) {
		return addInteger(date, Calendar.MONTH, yearAmount);
	}

	/**
	 * 增加日期的天数。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加天数后的日期字符串
	 */
	public static String addDay(String date, int dayAmount) {
		return addInteger(date, Calendar.DATE, dayAmount);
	}

	/**
	 * 增加日期的天数。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加天数后的日期
	 */
	public static Date addDay(Date date, int dayAmount) {
		return addInteger(date, Calendar.DATE, dayAmount);
	}

	/**
	 * 增加日期的小时。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加小时后的日期字符串
	 */
	public static String addHour(String date, int hourAmount) {
		return addInteger(date, Calendar.HOUR_OF_DAY, hourAmount);
	}

	/**
	 * 增加日期的小时。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加小时后的日期
	 */
	public static Date addHour(Date date, int hourAmount) {
		return addInteger(date, Calendar.HOUR_OF_DAY, hourAmount);
	}

	/**
	 * 增加日期的分钟。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加分钟后的日期字符串
	 */
	public static String addMinute(String date, int hourAmount) {
		return addInteger(date, Calendar.MINUTE, hourAmount);
	}

	/**
	 * 增加日期的分钟。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加分钟后的日期
	 */
	public static Date addMinute(Date date, int hourAmount) {
		return addInteger(date, Calendar.MINUTE, hourAmount);
	}

	/**
	 * 增加日期的秒钟。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加秒钟后的日期字符串
	 */
	public static String addSecond(String date, int hourAmount) {
		return addInteger(date, Calendar.SECOND, hourAmount);
	}

	/**
	 * 增加日期的秒钟。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @param dayAmount
	 *            增加数量。可为负数
	 * @return 增加秒钟后的日期
	 */
	public static Date addSecond(Date date, int hourAmount) {
		return addInteger(date, Calendar.SECOND, hourAmount);
	}

	/**
	 * 获取日期的年份。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 年份
	 */
	public static int getYear(String date) {
		return getYear(StringToDate(date));
	}

	/**
	 * 获取日期的年份。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 年份
	 */
	public static int getYear(Date date) {
		return getInteger(date, Calendar.YEAR);
	}

	/**
	 * 获取日期的月份。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 月份
	 */
	public static int getMonth(String date) {
		return getMonth(StringToDate(date));
	}

	/**
	 * 获取日期的月份。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 月份
	 */
	public static int getMonth(Date date) {
		return getInteger(date, Calendar.MONTH);
	}

	/**
	 * 获取日期的天数。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 天
	 */
	public static int getDay(String date) {
		return getDay(StringToDate(date));
	}

	/**
	 * 获取日期的天数。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 天
	 */
	public static int getDay(Date date) {
		return getInteger(date, Calendar.DATE);
	}

	/**
	 * 获取日期的小时。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 小时
	 */
	public static int getHour(String date) {
		return getHour(StringToDate(date));
	}

	/**
	 * 获取日期的小时。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 小时
	 */
	public static int getHour(Date date) {
		return getInteger(date, Calendar.HOUR_OF_DAY);
	}

	/**
	 * 获取日期的分钟。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 分钟
	 */
	public static int getMinute(String date) {
		return getMinute(StringToDate(date));
	}

	/**
	 * 获取日期的分钟。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 分钟
	 */
	public static int getMinute(Date date) {
		return getInteger(date, Calendar.MINUTE);
	}

	/**
	 * 获取日期的秒钟。失败返回0。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 秒钟
	 */
	public static int getSecond(String date) {
		return getSecond(StringToDate(date));
	}

	/**
	 * 获取日期的秒钟。失败返回0。
	 * 
	 * @param date
	 *            日期
	 * @return 秒钟
	 */
	public static int getSecond(Date date) {
		return getInteger(date, Calendar.SECOND);
	}

	/**
	 * 获取日期。默认yyyy-MM-dd格式。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @return 日期
	 */
	public static String getDate(Date date) {
		return DateToString(date, DateStyle.YYYY_MM_DD);
	}

	/**
	 * 获取日期的时间。默认HH:mm:ss格式。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 时间
	 */
	public static String getTime(String date) {
		return StringToString(date, DateStyle.HH_MM_SS);
	}

	/**
	 * 获取日期的时间。默认HH:mm:ss格式。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @return 时间
	 */
	public static String getTime(Date date) {
		return DateToString(date, DateStyle.HH_MM_SS);
	}

	/**
	 * 获取日期的星期。失败返回null。
	 * 
	 * @param date
	 *            日期字符串
	 * @return 星期
	 */
	public static Week getWeek(String date) {
		Week week = null;
		DateStyle dateStyle = getDateStyle(date);
		if (dateStyle != null) {
			Date myDate = StringToDate(date, dateStyle);
			week = getWeek(myDate);
		}
		return week;
	}

	/**
	 * 获取日期的星期。失败返回null。
	 * 
	 * @param date
	 *            日期
	 * @return 星期
	 */
	public static Week getWeek(Date date) {
		Week week = null;
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		int weekNumber = calendar.get(Calendar.DAY_OF_WEEK) - 1;
		switch (weekNumber) {
		case 0:
			week = Week.SUNDAY;
			break;
		case 1:
			week = Week.MONDAY;
			break;
		case 2:
			week = Week.TUESDAY;
			break;
		case 3:
			week = Week.WEDNESDAY;
			break;
		case 4:
			week = Week.THURSDAY;
			break;
		case 5:
			week = Week.FRIDAY;
			break;
		case 6:
			week = Week.SATURDAY;
			break;
		}
		return week;
	}

	/**
	 * 获取两个日期相差的天数
	 * 
	 * @param date
	 *            日期字符串
	 * @param otherDate
	 *            另一个日期字符串
	 * @return 相差天数
	 */
	public static int getIntervalDays(String date, String otherDate) {
		return getIntervalDays(StringToDate(date), StringToDate(otherDate));
	}

	/**
	 * @param date
	 *            日期
	 * @param otherDate
	 *            另一个日期
	 * @return 相差天数
	 */
	public static int getIntervalDays(Date date, Date otherDate) {
		date = DateUtil.StringToDate(DateUtil.getDate(date));
		long time = Math.abs(date.getTime() - otherDate.getTime());
		return (int) time / (24 * 60 * 60 * 1000);
	}

	/**
	 * 把字符串转换成日期类型 比如: 把字符串20121212转换成日期类型
	 * 
	 * @param dateString
	 *            要转换的字符串
	 * @param fomart
	 *            转换成的格式
	 * @return
	 */
	public static Date fomartStringToDate(String dateString, String fomart) {
		SimpleDateFormat sdf = new SimpleDateFormat(fomart);
		Date date = null;
		try {
			date = sdf.parse(dateString);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		return date;
	}

	/**
	 * 把日期转换成字符串
	 * 
	 * @param date
	 * @param fomart
	 * @return
	 */
	public static String fomartDateToString(Date date, String fomart) {
		SimpleDateFormat sdf = new SimpleDateFormat(fomart);
		return sdf.format(date);
	}

	/**
	 * 根据一个日期, 获得这个日期后的某一天的日期, 就是日期的计算 比如: 日期20121213 + 30天的日期
	 * 
	 * @param date
	 *            指定日期
	 * @param formart
	 *            格式化的格式
	 * @param days
	 *            天数
	 * @return
	 */
	public static String getSpecifiedDayAfterDate(Date date, String formart,
			Integer days) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		now.set(Calendar.DATE, now.get(Calendar.DATE) + days);
		return fomartDateToString(now.getTime(), formart);
	}

	/**
	 * 获得当前日期时间
	 * 
	 * @return
	 */
	public static String getCurrentDateTime(Date date) {
		SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		return sd.format(date);
	}

	/**
	 * 获得当前日期
	 * 
	 * @return
	 */
	public static String getCurrentDate(Date date, String formart) {
		SimpleDateFormat sd = new SimpleDateFormat(formart);
		return sd.format(date);
	}

	/**
	 * 获得指定日期的前一天
	 * 
	 * @param specifiedDay
	 * @param format
	 *            yyyy-MM-dd / yyyy-MM-dd hh:mm:ss
	 * @return
	 * @throws Exception
	 */
	public static String getSpecifiedDayBefore(String specifiedDay,
			String format) {
		Calendar c = Calendar.getInstance();
		Date date = null;
		try {
			date = new SimpleDateFormat(format).parse(specifiedDay);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		c.setTime(date);
		int day = c.get(Calendar.DATE);
		c.set(Calendar.DATE, day - 1);

		String dayBefore = new SimpleDateFormat(format).format(c.getTime());
		return dayBefore;
	}

	/**
	 * 获得指定日期的后一天
	 * 
	 * @param specifiedDay
	 * @param format
	 *            yyyy-MM-dd / yyyy-MM-dd hh:mm:ss
	 * @return
	 */
	public static String getSpecifiedDayAfter(String specifiedDay, String format) {
		Calendar c = Calendar.getInstance();
		Date date = null;
		try {
			date = new SimpleDateFormat(format).parse(specifiedDay);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		c.setTime(date);
		int day = c.get(Calendar.DATE);
		c.set(Calendar.DATE, day + 1);

		String dayAfter = new SimpleDateFormat(format).format(c.getTime());
		return dayAfter;
	}

	/**
	 * 根据日期获得所在周的日期
	 * 
	 * @param mdate
	 * @return
	 */
	@SuppressWarnings("deprecation")
	public static List<Date> dateToWeek(String dateString) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		Date mdate;
		List<Date> list = new ArrayList<Date>();
		try {
			mdate = sdf.parse(dateString);
			int b = mdate.getDay();
			Date fdate;
			Long fTime = mdate.getTime() - b * 24 * 3600000;
			for (int a = 0; a <= 7; a++) {
				fdate = new Date();
				fdate.setTime(fTime + (a * 24 * 3600000));
				list.add(a, fdate);
			}
		} catch (ParseException e) {
			e.printStackTrace();
		}

		return list;
	}

	/**
	 * 获得最近七天的日期
	 * 
	 * @return
	 */
	public static List<Date> getRecently7Days() {
		List<Date> the7Days = new ArrayList<Date>();
		try {
			String currentDate = getCurrentDate(new Date(), "yyyy-MM-dd");
			String specDay = currentDate;
			String specBeforeDay = currentDate;
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
			for (int i = 0; i < 7; i++) {
				specDay = specBeforeDay;
				specBeforeDay = getSpecifiedDayBefore(specDay, "yyyy-MM-dd");
				the7Days.add(i, sdf.parse(specBeforeDay));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return the7Days;
	}

	/**
	 * 根据一个日期获得一个起始日期和一个结束日期
	 * 
	 * @param specDay
	 *            日期
	 * @param timeStamp
	 *            时间戳
	 * @return
	 */
	public static String[] getStartAndEndTime(String specDay, String timeStamp) {
		String[] stratAndEndTime = new String[2];
		String specifiedDay = specDay + " " + timeStamp;
		stratAndEndTime[0] = getSpecifiedDayBefore(specifiedDay, "yyyy-MM-dd")
				+ " " + timeStamp;
		stratAndEndTime[1] = specifiedDay;
		return stratAndEndTime;

	}

	/**
	 * 时间戳比较日期是否一样
	 * 
	 * @param specDay
	 *            日期
	 * @param timeStamp
	 *            时间戳
	 * @return
	 */
	public static boolean compareDate(Date date1, Date date2) {

		String dd1 = getDate(date1);
		String dd2 = getDate(date2);

		if (dd1.equals(dd2)) {

			return true;
		}
		return false;

	}
	
	/**
	 * 时间戳比较日期是否一样
	 * 
	 * @param specDay
	 *            日期
	 * @param timeStamp
	 *            时间戳
	 * @return
	 */
	
	public static String getNextQuarter(String date1) {
		int year=getYear(date1);
     int n=getMonth(date1)+1;
  String m="";
		if(n<3){
			m="12";
			year--;
		
		}else if(n==12){
			
			m="12";
		}
		else if(n<6){
			m="03";
		
		}
		else if(n<9){
			m="06";
		
		}
		else if(n<12){
			m="09";
		
		}
		
	
		return  addMonth(year+"-"+m, 3);
		}
	
	
	public static String getLastQuarter(String date1) {
		int year=getYear(date1);
	    int n=getMonth(date1)+1;
	    String m="";
			if(n<3){
				m="3";
			
			
			}else if(n==12){
				
				m="03";
				year++;
			}
			else if(n<6){
				m="06";
			
			}
			else if(n<9){
				m="09";
			
			}
			else if(n<12){
				m="12";
			
			}
			
		
			return  addMonth(year+"-"+m, -3);
		}
//当前填天下几天
	public static Date getDateByCurDay(Date date,
			int value,int second) {
		Calendar now = Calendar.getInstance();
		now.setTime(date);
		now.set(Calendar.HOUR_OF_DAY, 0);
		now.set(Calendar.MINUTE, 0);
		now.set(Calendar.SECOND, 0);
		now.set(Calendar.MILLISECOND, 0);
		now.add(Calendar.DATE, value);
		now.add(Calendar.SECOND, second);
		return  now.getTime();
	
		
		
	}
	//当前月的下一个月 （月初开始）
		public static Date getDateByCurMon(Date date,
				int value,int second) {
			Calendar now = Calendar.getInstance();
			now.setTime(date);
			now.set(Calendar.DATE, 1);
			now.set(Calendar.HOUR_OF_DAY, 0);
			now.set(Calendar.MINUTE, 0);
			now.set(Calendar.SECOND, 0);
			now.set(Calendar.MILLISECOND, 0);
			now.add(Calendar.MONTH, value);
		
//			now.add(Calendar.SECOND, second);
			return  now.getTime();
		
			
			
		}
}